package Utils;

import java.beans.PropertyDescriptor;
import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.apache.commons.lang3.StringUtils;

/**
 * 反射工具类 <br />
 * <br />
 * 提供了一系列的获取某一个类的信息的方法<br />
 * 包括获取全类名，实现的接口，接口的泛型等<br />
 * 并且提供了根据Class类型获取对应的实例对象的方法，以及修改属性和调用对象的方法等
 */
public class ReflectionUtils {
	
	
	/**
     * 通过字段名从对象或对象的父类中得到字段的值
     * @param object 对象实例
     * @param fieldName 字段名
     * @return 字段对应的值
     * @throws Exception
     */
    public static Object getValue(Object object, String fieldName) throws Exception {
        if (object == null) {
            return null;
        }
        if (StringUtils.isBlank(fieldName)) {
            return null;
        }
        Field field = null;
        Class<?> clazz = object.getClass();
        for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
            try {
                field = clazz.getDeclaredField(fieldName);
                field.setAccessible(true);
                return field.get(object);
            } catch (Exception e) {
                //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
                //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
            }
        }
        return null;
    }

   
 /**
     * 通过字段名从对象或对象的父类中得到字段的值（调用字典的get方法）
     * @param object 对象实例
     * @param fieldName 字段名
     * @return 字段对应的值
     * @throws Exception
     */
    public static Object getValueOfGet(Object object, String fieldName) throws Exception {
        if (object == null) {
            return null;
        }
        if (StringUtils.isBlank(fieldName)) {
            return null;
        }
        Field field = null;
        Class<?> clazz = object.getClass();
        for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
            try {
                field = clazz.getDeclaredField(fieldName);
                field.setAccessible(true);

                PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
                //获得get方法
                Method getMethod = pd.getReadMethod();
                //执行get方法返回一个Object
                return getMethod.invoke(object);
            } catch (Exception e) {
                //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
                //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
            }
        }

        return null;
    }

  /*  *//**
     * 通过字段名从对象或对象的父类中得到字段的值（调用字典的get方法，可以取出复杂的对象的值）
     * @param object 对象实例
     * @param fieldName 字段名
     * @return 字段对应的值
     * @throws Exception
     *//*
    public static Object getValueOfGetIncludeObjectFeild(Object object, String fieldName)
            throws Exception {

        if (object == null) {
            return null;
        }
        if (StringUtils.isBlank(fieldName)) {
            return null;
        }

        if(HashMap.class.equals(object.getClass())){
            return ((Map)object).get(fieldName);
        }

        Field field = null;
        Class<?> clazz = object.getClass();
        for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
            try {
                if (fieldName.contains(".")) {
                    // 如：operatorUser.name、operatorUser.org.name，递归调用
                    String[] splitFiledName = fieldName.split("\\.");
                    return getValueOfGetIncludeObjectFeild(
                            getValueOfGetIncludeObjectFeild(object, splitFiledName[0]),
                            splitFiledName[1]);
                }
                field = clazz.getDeclaredField(fieldName);
                field.setAccessible(true);

                PropertyDescriptor pd = new PropertyDescriptor(field.getName(), clazz);
                //获得get方法
                Method getMethod = pd.getReadMethod();
                //执行get方法返回一个Object
                return getMethod.invoke(object);
            } catch (Exception e) {
                //这里甚么都不要做！并且这里的异常必须这样写，不能抛出去。
                //如果这里的异常打印或者往外抛，则就不会执行clazz = clazz.getSuperclass(),最后就不会进入到父类中了
            }
        }

        return null;
    }*/

	public  void scanPackages(String packageName,List<String> clzList){
		//获取指定包的完整路径
		String packagesUrl=this.getClass().getClassLoader().getResource("/"+packageName.replaceAll("\\.", "/")).getFile();
		File scanFile=new File(packagesUrl);
		String[] filenameList=scanFile.list();
		
		for(String filename:filenameList){
			File file=new File(scanFile,filename);
			if(file.isDirectory()){
				scanPackages(packageName+"."+filename,clzList);
			}else{
				if(filename.indexOf(".class")>0)
					clzList.add(packageName+"."+filename.replace(".class", ""));
			}
		}
	}


/**
 * 获取包名
 * 
 * @return 包名【String类型】
 */
public static String getPackage(Class<?> clazz) {
    Package pck = clazz.getPackage();
    if (null != pck) {
        return pck.getName();
    } else {
        return "没有包！";
    }
}

/**
 * 获取继承的父类的全类名
 * 
 * @return 继承的父类的全类名【String类型】
 */
public static String getSuperClassName(Class<?> clazz) {
    Class<?> superClass = clazz.getSuperclass();
    if (null != superClass) {
        return superClass.getName();
    } else {
        return "没有父类！";
    }
}

/**
 * 获取全类名
 * 
 * @return 全类名【String类型】
 */
public static String getClassName(Class<?> clazz) {
    return clazz.getName();
}

/**
 * 获取实现的接口名
 * 
 * @return 所有的接口名【每一个接口名的类型为String，最后保存到一个List集合中】
 */
public static List<String> getInterfaces(Class<?> clazz) {
    Class<?>[] interfaces = clazz.getInterfaces();
    int len = interfaces.length;

    List<String> list = new ArrayList<String>();
    for (int i = 0; i < len; i++) {
        Class<?> itfc = interfaces[i];

        // 接口名
        String interfaceName = itfc.getSimpleName();

        list.add(interfaceName);
    }

    return list;
}

/**
 * 获取所有属性
 * 
 * @return 所有的属性【每一个属性添加到StringBuilder中，最后保存到一个List集合中】
 */
public static List<StringBuilder> getFields(Class<?> clazz) {
    Field[] fields = clazz.getDeclaredFields();
    int len = fields.length;

    List<StringBuilder> list = new ArrayList<StringBuilder>();
    StringBuilder sb = null;
    for (int i = 0; i < len; i++) {
        Field field = fields[i];
        sb = new StringBuilder();

        // 修饰符
        String modifier = Modifier.toString(field.getModifiers());
        sb.append(modifier + " ");

        // 数据类型
        Class<?> type = field.getType();
        String typeName = type.getSimpleName();
        sb.append(typeName + " ");

        // 属性名
        String fieldName = field.getName();
        sb.append(fieldName + ";");

        list.add(sb);
    }

    return list;
}

/**
 * 获取所有公共的属性
 * 
 * @return 所有公共的属性【每一个属性添加到StringBuilder中，最后保存到一个List集合中】
 */
public static List<StringBuilder> getPublicFields(Class<?> clazz) {
    Field[] fields = clazz.getFields();
    int len = fields.length;

    List<StringBuilder> list = new ArrayList<StringBuilder>();
    StringBuilder sb = null;
    for (int i = 0; i < len; i++) {
        Field field = fields[i];
        sb = new StringBuilder();

        // 修饰符
        String modifier = Modifier.toString(field.getModifiers());
        sb.append(modifier + " ");

        // 数据类型
        Class<?> type = field.getType();
        String typeName = type.getSimpleName();
        sb.append(typeName + " ");

        // 属性名
        String fieldName = field.getName();
        sb.append(fieldName + ";");

        list.add(sb);
    }

    return list;
}

/**
 * 获取所有构造方法
 * 
 * @return 所有的构造方法【每一个构造方法添加到StringBuilder中，最后保存到一个List集合中】
 */
public static List<StringBuilder> getConstructors(Class<?> clazz) {
    Constructor<?>[] constructors = clazz.getDeclaredConstructors();
    int len = constructors.length;

    List<StringBuilder> list = new ArrayList<StringBuilder>();
    StringBuilder sb = null;
    for (int i = 0; i < len; i++) {
        Constructor<?> constructor = constructors[i];
        sb = new StringBuilder();

        // 修饰符
        String modifier = Modifier.toString(constructor.getModifiers());
        sb.append(modifier + " ");

        // 方法名（类名）
        String constructorName = clazz.getSimpleName();
        sb.append(constructorName + " (");

        // 形参列表
        Class<?>[] parameterTypes = constructor.getParameterTypes();
        int length = parameterTypes.length;
        for (int j = 0; j < length; j++) {
            Class<?> parameterType = parameterTypes[j];

            String parameterTypeName = parameterType.getSimpleName();

            if (j < length - 1) {
                sb.append(parameterTypeName + ", ");
            } else {
                sb.append(parameterTypeName);
            }

        }

        sb.append(") {}");

        list.add(sb);
    }

    return list;
}

/**
 * 获取所有自身的方法
 * 
 * @return 所有自身的方法【每一个方法添加到StringBuilder中，最后保存到一个List集合中】
 */
public static List<StringBuilder> getMethods(Class<?> clazz) {
    Method[] methods = clazz.getDeclaredMethods();
    int len = methods.length;

    List<StringBuilder> list = new ArrayList<StringBuilder>();
    StringBuilder sb = null;
    for (int i = 0; i < len; i++) {
        Method method = methods[i];
        sb = new StringBuilder();

        // 修饰符
        String modifier = Modifier.toString(method.getModifiers());
        sb.append(modifier + " ");

        // 返回值类型
        Class<?> returnClass = method.getReturnType();
        String returnType = returnClass.getSimpleName();
        sb.append(returnType + " ");

        // 方法名
        String methodName = method.getName();
        sb.append(methodName + " (");

        // 形参列表
        Class<?>[] parameterTypes = method.getParameterTypes();
        int length = parameterTypes.length;

        for (int j = 0; j < length; j++) {
            Class<?> parameterType = parameterTypes[j];

            // 形参类型
            String parameterTypeName = parameterType.getSimpleName();

            if (j < length - 1) {
                sb.append(parameterTypeName + ", ");
            } else {
                sb.append(parameterTypeName);
            }

        }

        sb.append(") {}");

        list.add(sb);
    }

    return list;
}

/**
 * 获取所有公共的方法
 * 
 * @return 所有公共的方法【每一个方法添加到StringBuilder中，最后保存到一个List集合中】
 */
public static List<StringBuilder> getPublicMethods(Class<?> clazz) {
    Method[] methods = clazz.getMethods();
    int len = methods.length;

    List<StringBuilder> list = new ArrayList<StringBuilder>();
    StringBuilder sb = null;
    for (int i = 0; i < len; i++) {
        Method method = methods[i];
        sb = new StringBuilder();

        // 修饰符
        String modifier = Modifier.toString(method.getModifiers());
        sb.append(modifier + " ");

        // 返回值类型
        Class<?> returnClass = method.getReturnType();
        String returnType = returnClass.getSimpleName();
        sb.append(returnType + " ");

        // 方法名
        String methodName = method.getName();
        sb.append(methodName + " (");

        // 形参列表
        Class<?>[] parameterTypes = method.getParameterTypes();
        int length = parameterTypes.length;

        for (int j = 0; j < length; j++) {
            Class<?> parameterType = parameterTypes[j];

            // 形参类型
            String parameterTypeName = parameterType.getSimpleName();

            if (j < length - 1) {
                sb.append(parameterTypeName + ", ");
            } else {
                sb.append(parameterTypeName);
            }

        }

        sb.append(") {}");

        list.add(sb);
    }

    return list;
}

/**
 * 获取所有的注解名
 * 
 * @return 所有的注解名【每一个注解名的类型为String，最后保存到一个List集合中】
 */
public static List<String> getAnnotations(Class<?> clazz) {
    Annotation[] annotations = clazz.getAnnotations();
    int len = annotations.length;

    List<String> list = new ArrayList<String>();
    for (int i = 0; i < len; i++) {
        Annotation annotation = annotations[i];

        String annotationName = annotation.annotationType().getSimpleName();
        list.add(annotationName);
    }

    return list;
}

/**
 * 获取父类的泛型
 * 
 * @return 父类的泛型【Class类型】
 */
public static Class<?> getSuperClassGenericParameterizedType(Class<?> clazz) {
    Type genericSuperClass = clazz.getGenericSuperclass();

    Class<?> superClassGenericParameterizedType = null;

    // 判断父类是否有泛型
    if (genericSuperClass instanceof ParameterizedType) {
        // 向下转型，以便调用方法
        ParameterizedType pt = (ParameterizedType) genericSuperClass;
        // 只取第一个，因为一个类只能继承一个父类
        Type superClazz = pt.getActualTypeArguments()[0];
        // 转换为Class类型
        superClassGenericParameterizedType = (Class<?>) superClazz;
    }

    return superClassGenericParameterizedType;
}

/**
 * 获取接口的所有泛型
 * 
 * @return 所有的泛型接口【每一个泛型接口的类型为Class，最后保存到一个List集合中】
 */
public static List<Class<?>> getInterfaceGenericParameterizedTypes(Class<?> clazz) {
    Type[] genericInterfaces = clazz.getGenericInterfaces();
    int len = genericInterfaces.length;

    List<Class<?>> list = new ArrayList<Class<?>>();
    for (int i = 0; i < len; i++) {
        Type genericInterface = genericInterfaces[i];

        // 判断接口是否有泛型
        if (genericInterface instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) genericInterface;

            // 得到所有的泛型【Type类型的数组】
            Type[] interfaceTypes = pt.getActualTypeArguments();

            int length = interfaceTypes.length;

            for (int j = 0; j < length; j++) {
                // 获取对应的泛型【Type类型】
                Type interfaceType = interfaceTypes[j];
                // 转换为Class类型
                Class<?> interfaceClass = (Class<?>) interfaceType;
                list.add(interfaceClass);
            }

        }

    }

    return list;
}

/**
 * 打印包名
 */
public static void printPackage(Class<?> clazz) {
    System.out.println(getPackage(clazz));
}

/**
 * 打印继承的父类的全类名
 */
public static void printSuperClassName(Class<?> clazz) {
    System.out.println(getSuperClassName(clazz));
}

/**
 * 打印全类名
 */
public static void printClassName(Class<?> clazz) {
    System.out.println(getClassName(clazz));
}

/**
 * 打印实现的接口
 */
public static void printInterfaces(Class<?> clazz) {
    List<String> list = getInterfaces(clazz);
    int size = list.size();
    if (0 < size) {
        for (int i = 0; i < size; i++) {
            System.out.println(list.get(i));
        }
    } else {
        System.out.println("没有实现接口！");
    }
}

/**
 * 打印所有属性
 */
public static void printFields(Class<?> clazz) {
    List<StringBuilder> list = getFields(clazz);
    int size = list.size();
    if (0 < size) {
        for (int i = 0; i < size; i++) {
            System.out.println(list.get(i));
        }
    } else {
        System.out.println("没有属性！");
    }
}

/**
 * 打印所有公共的属性
 */
public static void printPublicFields(Class<?> clazz) {
    List<StringBuilder> list = getPublicFields(clazz);
    int size = list.size();
    if (0 < size) {
        for (int i = 0; i < size; i++) {
            System.out.println(list.get(i));
        }
    } else {
        System.out.println("没有属性！");
    }
}

/**
 * 打印所有构造方法
 */
public static void printConstructors(Class<?> clazz) {
    List<StringBuilder> list = getConstructors(clazz);
    int size = list.size();
    if (0 < size) {
        for (int i = 0; i < size; i++) {
            System.out.println(list.get(i));
        }
    } else {
        System.out.println("没有构造方法！");
    }
}

/**
 * 打印所有方法
 */
public static void printMethods(Class<?> clazz) {
    List<StringBuilder> list = getMethods(clazz);
    int size = list.size();
    if (0 < size) {
        for (int i = 0; i < size; i++) {
            System.out.println(list.get(i));
        }
    } else {
        System.out.println("没有方法！");
    }
}

/**
 * 打印所有公共的方法
 */
public static void printPublicMethods(Class<?> clazz) {
    List<StringBuilder> list = getPublicMethods(clazz);
    int size = list.size();
    if (0 < size) {
        for (int i = 0; i < size; i++) {
            System.out.println(list.get(i));
        }
    } else {
        System.out.println("没有方法！");
    }
}

/**
 * 打印所有的注解
 */
public static void printAnnotations(Class<?> clazz) {
    List<String> list = getAnnotations(clazz);
    int size = list.size();
    if (0 < size) {
        for (int i = 0; i < size; i++) {
            System.out.println(list.get(i));
        }
    } else {
        System.out.println("没有注解！");
    }
}

/**
 * 打印父类的泛型名
 */
public static void printSuperClassGenericParameterizedType(Class<?> clazz) {
    Class<?> superClassGenericParameterizedType = getSuperClassGenericParameterizedType(clazz);
    if (null != superClassGenericParameterizedType) {
        System.out.println(superClassGenericParameterizedType.getSimpleName());
    } else {
        System.out.println("父类没有泛型！");
    }
}

/**
 * 打印接口的泛型
 */
public static void printInterfaceGenericParameterizedTypes(Class<?> clazz) {
    List<Class<?>> list = getInterfaceGenericParameterizedTypes(clazz);
    int size = list.size();
    if (0 < size) {
        for (int i = 0; i < size; i++) {
            System.out.println(list.get(i).getSimpleName());
        }
    } else {
        System.out.println("没有泛型接口！");
    }
}

/**
 * 打印一个类的相关信息
 * 
 * @param clazz
 */
public static void printAll(Class<?> clazz) {
    System.out.print("【包名】  ");
    printPackage(clazz);

    System.out.print("【类名】  ");
    System.out.println(clazz.getSimpleName());

    System.out.println("\n【父类全类名】");
    printSuperClassName(clazz);
    System.out.println("【全类名】");
    printClassName(clazz);
    System.out.println("\n【所有已实现的接口】");
    printInterfaces(clazz);

    System.out.println("\n【属性】");
    printFields(clazz);
    System.out.println("\n【构造方法】");
    printConstructors(clazz);
    System.out.println("\n【方法】");
    printMethods(clazz);

    System.out.println("\n【公共的属性】");
    printPublicFields(clazz);
    System.out.println("\n【公共的方法】");
    printPublicMethods(clazz);
}

/**
 * 根据Class类型，获取对应的实例【要求必须有无参的构造器】
 * 
 * @return 对应的实例【Object类型】
 */
public static Object getNewInstance(Class<?> clazz) throws InstantiationException, IllegalAccessException {
    return clazz.newInstance();
}

/**
 * 根据传入的类的Class对象，以及构造方法的形参的Class对象，获取对应的构造方法对象
 * 
 * @param clazz
 *            类的Class对象
 * @param parameterTypes
 *            构造方法的形参的Class对象【可以不写】
 * @return 构造方法对象【Constructor类型】
 */
public static Constructor<?> getConstructor(Class<?> clazz, Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
    return clazz.getDeclaredConstructor(parameterTypes);
}

/**
 * 根据传入的构造方法对象，以及，获取对应的实例
 * 
 * @param constructor
 *            构造方法对象
 * @param initargs
 *            传入构造方法的实参【可以不写】
 * @return 对应的实例【Object类型】
 */
public static Object getNewInstance(Constructor<?> constructor, Object... initargs)
        throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    constructor.setAccessible(true);
    return constructor.newInstance(initargs);
}



public static void SetFieldValue(Object o,String name,Object value)
{
	try {
		Field f=o.getClass().getField(name);
		if(f!=null)
		{
			try {
				f.set(o, value);
			} catch (IllegalArgumentException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	} catch (NoSuchFieldException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (SecurityException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
  
}

/**
 * 根据传入的属性名字符串，修改对应的属性值
 * 
 * @param clazz
 *            类的Class对象
 * @param name
 *            属性名
 * @param obj
 *            要修改的实例对象
 * @param value
 *            修改后的新值
 */
public static void setField(Class<?> clazz, String name, Object obj, Object value)
        throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
    Field field = clazz.getDeclaredField(name);
    field.setAccessible(true);
    field.set(obj, value);
}

/**
 * 根据传入的方法名字符串，获取对应的方法
 * 
 * @param clazz
 *            类的Class对象
 * @param name
 *            方法名
 * @param parameterTypes
 *            方法的形参对应的Class类型【可以不写】
 * @return 方法对象【Method类型】
 */
public static Method getMethod(Class<?> clazz, String name, Class<?>... parameterTypes)
        throws NoSuchMethodException, SecurityException {
    return clazz.getDeclaredMethod(name, parameterTypes);
}

/**
 * 根据传入的方法对象，调用对应的方法
 * 
 * @param method
 *            方法对象
 * @param obj
 *            要调用的实例对象【如果是调用静态方法，则可以传入null】
 * @param args
 *            传入方法的实参【可以不写】
 * @return 方法的返回值【没有返回值，则返回null】
 */
public static Object invokeMethod(Method method, Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    method.setAccessible(true);
    return method.invoke(obj, args);
}

}
